use :: libc;
extern "C" {
    pub type event_base;
    pub type evbuffer;
    pub type bufferevent_ops;
    pub type args;
    pub type tmuxpeer;
    pub type hyperlinks;
    pub type screen_write_cline;
    pub type screen_sel;
    pub type screen_titles;
    pub type environ;
    pub type options;
    pub type format_tree;
    pub type input_ctx;
    pub type cmdq_item;
    pub type tty_key;
    pub type tty_code;
    pub type format_job_tree;
    pub type control_state;
    pub type cmdq_list;
    pub type options_array_item;
    pub type options_entry;
    fn free(_: *mut libc::c_void);
    fn strcmp(_: *const i8, _: *const i8) -> i32;
    fn strncmp(_: *const i8, _: *const i8, _: u64) -> i32;
    fn strchr(_: *const i8, _: i32) -> *mut i8;
    fn strlen(_: *const i8) -> u64;
    fn strlcpy(_: *mut i8, _: *const i8, _: size_t) -> size_t;
    fn strlcat(_: *mut i8, _: *const i8, _: size_t) -> size_t;
    fn xmalloc(_: size_t) -> *mut libc::c_void;
    fn xcalloc(_: size_t, _: size_t) -> *mut libc::c_void;
    fn xrealloc(_: *mut libc::c_void, _: size_t) -> *mut libc::c_void;
    fn xreallocarray(_: *mut libc::c_void, _: size_t, _: size_t) -> *mut libc::c_void;
    fn xstrdup(_: *const i8) -> *mut i8;
    fn xasprintf(_: *mut *mut i8, _: *const i8, _: ...) -> i32;
    fn xvasprintf(_: *mut *mut i8, _: *const i8, _: ::core::ffi::VaList) -> i32;
    static mut global_options: *mut options;
    fn options_get_only(_: *mut options, _: *const i8) -> *mut options_entry;
    fn options_array_first(_: *mut options_entry) -> *mut options_array_item;
    fn options_array_next(_: *mut options_array_item) -> *mut options_array_item;
    fn options_array_item_value(_: *mut options_array_item) -> *mut options_value;
    fn args_parse(_: *const args_parse, _: *mut args_value, _: u_int, _: *mut *mut i8)
        -> *mut args;
    fn args_copy(_: *mut args, _: i32, _: *mut *mut i8) -> *mut args;
    fn args_free(_: *mut args);
    fn args_print(_: *mut args) -> *mut i8;
    fn args_escape(_: *const i8) -> *mut i8;
    fn winlink_find_by_window(_: *mut winlinks, _: *mut window) -> *mut winlink;
    fn window_find_by_id(_: u_int) -> *mut window;
    fn window_has_pane(_: *mut window, _: *mut window_pane) -> i32;
    fn window_pane_find_by_id(_: u_int) -> *mut window_pane;
    fn session_find_by_id(_: u_int) -> *mut session;
    fn log_debug(_: *const i8, _: ...);
    static cmd_attach_session_entry: cmd_entry;
    static cmd_bind_key_entry: cmd_entry;
    static cmd_break_pane_entry: cmd_entry;
    static cmd_capture_pane_entry: cmd_entry;
    static cmd_choose_buffer_entry: cmd_entry;
    static cmd_choose_client_entry: cmd_entry;
    static cmd_choose_tree_entry: cmd_entry;
    static cmd_clear_history_entry: cmd_entry;
    static cmd_clear_prompt_history_entry: cmd_entry;
    static cmd_clock_mode_entry: cmd_entry;
    static cmd_command_prompt_entry: cmd_entry;
    static cmd_confirm_before_entry: cmd_entry;
    static cmd_copy_mode_entry: cmd_entry;
    static cmd_customize_mode_entry: cmd_entry;
    static cmd_delete_buffer_entry: cmd_entry;
    static cmd_detach_client_entry: cmd_entry;
    static cmd_display_menu_entry: cmd_entry;
    static cmd_display_message_entry: cmd_entry;
    static cmd_display_popup_entry: cmd_entry;
    static cmd_display_panes_entry: cmd_entry;
    static cmd_find_window_entry: cmd_entry;
    static cmd_has_session_entry: cmd_entry;
    static cmd_if_shell_entry: cmd_entry;
    static cmd_join_pane_entry: cmd_entry;
    static cmd_kill_pane_entry: cmd_entry;
    static cmd_kill_server_entry: cmd_entry;
    static cmd_kill_session_entry: cmd_entry;
    static cmd_kill_window_entry: cmd_entry;
    static cmd_last_pane_entry: cmd_entry;
    static cmd_last_window_entry: cmd_entry;
    static cmd_link_window_entry: cmd_entry;
    static cmd_list_buffers_entry: cmd_entry;
    static cmd_list_clients_entry: cmd_entry;
    static cmd_list_commands_entry: cmd_entry;
    static cmd_list_keys_entry: cmd_entry;
    static cmd_list_panes_entry: cmd_entry;
    static cmd_list_sessions_entry: cmd_entry;
    static cmd_list_windows_entry: cmd_entry;
    static cmd_load_buffer_entry: cmd_entry;
    static cmd_lock_client_entry: cmd_entry;
    static cmd_lock_server_entry: cmd_entry;
    static cmd_lock_session_entry: cmd_entry;
    static cmd_move_pane_entry: cmd_entry;
    static cmd_move_window_entry: cmd_entry;
    static cmd_new_session_entry: cmd_entry;
    static cmd_new_window_entry: cmd_entry;
    static cmd_next_layout_entry: cmd_entry;
    static cmd_next_window_entry: cmd_entry;
    static cmd_paste_buffer_entry: cmd_entry;
    static cmd_pipe_pane_entry: cmd_entry;
    static cmd_previous_layout_entry: cmd_entry;
    static cmd_previous_window_entry: cmd_entry;
    static cmd_refresh_client_entry: cmd_entry;
    static cmd_rename_session_entry: cmd_entry;
    static cmd_rename_window_entry: cmd_entry;
    static cmd_resize_pane_entry: cmd_entry;
    static cmd_resize_window_entry: cmd_entry;
    static cmd_respawn_pane_entry: cmd_entry;
    static cmd_respawn_window_entry: cmd_entry;
    static cmd_rotate_window_entry: cmd_entry;
    static cmd_run_shell_entry: cmd_entry;
    static cmd_save_buffer_entry: cmd_entry;
    static cmd_select_layout_entry: cmd_entry;
    static cmd_select_pane_entry: cmd_entry;
    static cmd_select_window_entry: cmd_entry;
    static cmd_send_keys_entry: cmd_entry;
    static cmd_send_prefix_entry: cmd_entry;
    static cmd_server_access_entry: cmd_entry;
    static cmd_set_buffer_entry: cmd_entry;
    static cmd_set_environment_entry: cmd_entry;
    static cmd_set_hook_entry: cmd_entry;
    static cmd_set_option_entry: cmd_entry;
    static cmd_set_window_option_entry: cmd_entry;
    static cmd_show_buffer_entry: cmd_entry;
    static cmd_show_environment_entry: cmd_entry;
    static cmd_show_hooks_entry: cmd_entry;
    static cmd_show_messages_entry: cmd_entry;
    static cmd_show_options_entry: cmd_entry;
    static cmd_show_prompt_history_entry: cmd_entry;
    static cmd_show_window_options_entry: cmd_entry;
    static cmd_source_file_entry: cmd_entry;
    static cmd_split_window_entry: cmd_entry;
    static cmd_start_server_entry: cmd_entry;
    static cmd_suspend_client_entry: cmd_entry;
    static cmd_swap_pane_entry: cmd_entry;
    static cmd_swap_window_entry: cmd_entry;
    static cmd_switch_client_entry: cmd_entry;
    static cmd_unbind_key_entry: cmd_entry;
    static cmd_unlink_window_entry: cmd_entry;
    static cmd_wait_for_entry: cmd_entry;
}
pub type __builtin_va_list = [__va_list_tag; 1];
#[derive(Copy, Clone)]
#[repr(C)]
pub struct __va_list_tag {
    pub gp_offset: u32,
    pub fp_offset: u32,
    pub overflow_arg_area: *mut libc::c_void,
    pub reg_save_area: *mut libc::c_void,
}
pub type __u_char = u8;
pub type __u_short = u16;
pub type __u_int = u32;
pub type __uint8_t = u8;
pub type __uint64_t = u64;
pub type __pid_t = i32;
pub type __time_t = i64;
pub type __suseconds_t = i64;
pub type u_char = __u_char;
pub type u_short = __u_short;
pub type u_int = __u_int;
pub type pid_t = __pid_t;
pub type time_t = __time_t;
pub type size_t = u64;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct timeval {
    pub tv_sec: __time_t,
    pub tv_usec: __suseconds_t,
}
pub type va_list = __builtin_va_list;
pub type cc_t = u8;
pub type speed_t = u32;
pub type tcflag_t = u32;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct termios {
    pub c_iflag: tcflag_t,
    pub c_oflag: tcflag_t,
    pub c_cflag: tcflag_t,
    pub c_lflag: tcflag_t,
    pub c_line: cc_t,
    pub c_cc: [cc_t; 32],
    pub c_ispeed: speed_t,
    pub c_ospeed: speed_t,
}
pub type uint8_t = __uint8_t;
pub type uint64_t = __uint64_t;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct event {
    pub ev_evcallback: event_callback,
    pub ev_timeout_pos: C2RustUnnamed_4,
    pub ev_fd: i32,
    pub ev_base: *mut event_base,
    pub ev_: C2RustUnnamed,
    pub ev_events: i16,
    pub ev_res: i16,
    pub ev_timeout: timeval,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub union C2RustUnnamed {
    pub ev_io: C2RustUnnamed_2,
    pub ev_signal: C2RustUnnamed_0,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_0 {
    pub ev_signal_next: C2RustUnnamed_1,
    pub ev_ncalls: i16,
    pub ev_pncalls: *mut i16,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_1 {
    pub le_next: *mut event,
    pub le_prev: *mut *mut event,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_2 {
    pub ev_io_next: C2RustUnnamed_3,
    pub ev_timeout: timeval,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_3 {
    pub le_next: *mut event,
    pub le_prev: *mut *mut event,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub union C2RustUnnamed_4 {
    pub ev_next_with_common_timeout: C2RustUnnamed_5,
    pub min_heap_idx: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_5 {
    pub tqe_next: *mut event,
    pub tqe_prev: *mut *mut event,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct event_callback {
    pub evcb_active_next: C2RustUnnamed_7,
    pub evcb_flags: i16,
    pub evcb_pri: uint8_t,
    pub evcb_closure: uint8_t,
    pub evcb_cb_union: C2RustUnnamed_6,
    pub evcb_arg: *mut libc::c_void,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub union C2RustUnnamed_6 {
    pub evcb_callback: Option<unsafe extern "C" fn(i32, i16, *mut libc::c_void) -> ()>,
    pub evcb_selfcb: Option<unsafe extern "C" fn(*mut event_callback, *mut libc::c_void) -> ()>,
    pub evcb_evfinalize: Option<unsafe extern "C" fn(*mut event, *mut libc::c_void) -> ()>,
    pub evcb_cbfinalize: Option<unsafe extern "C" fn(*mut event_callback, *mut libc::c_void) -> ()>,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_7 {
    pub tqe_next: *mut event_callback,
    pub tqe_prev: *mut *mut event_callback,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct bufferevent {
    pub ev_base: *mut event_base,
    pub be_ops: *const bufferevent_ops,
    pub ev_read: event,
    pub ev_write: event,
    pub input: *mut evbuffer,
    pub output: *mut evbuffer,
    pub wm_read: event_watermark,
    pub wm_write: event_watermark,
    pub readcb: bufferevent_data_cb,
    pub writecb: bufferevent_data_cb,
    pub errorcb: bufferevent_event_cb,
    pub cbarg: *mut libc::c_void,
    pub timeout_read: timeval,
    pub timeout_write: timeval,
    pub enabled: i16,
}
pub type bufferevent_event_cb =
    Option<unsafe extern "C" fn(*mut bufferevent, i16, *mut libc::c_void) -> ()>;
pub type bufferevent_data_cb =
    Option<unsafe extern "C" fn(*mut bufferevent, *mut libc::c_void) -> ()>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct event_watermark {
    pub low: size_t,
    pub high: size_t,
}
pub type bitstr_t = u8;
pub type msgtype = u32;
pub const MSG_READ_CANCEL: msgtype = 307;
pub const MSG_WRITE_CLOSE: msgtype = 306;
pub const MSG_WRITE_READY: msgtype = 305;
pub const MSG_WRITE: msgtype = 304;
pub const MSG_WRITE_OPEN: msgtype = 303;
pub const MSG_READ_DONE: msgtype = 302;
pub const MSG_READ: msgtype = 301;
pub const MSG_READ_OPEN: msgtype = 300;
pub const MSG_FLAGS: msgtype = 218;
pub const MSG_EXEC: msgtype = 217;
pub const MSG_WAKEUP: msgtype = 216;
pub const MSG_UNLOCK: msgtype = 215;
pub const MSG_SUSPEND: msgtype = 214;
pub const MSG_OLDSTDOUT: msgtype = 213;
pub const MSG_OLDSTDIN: msgtype = 212;
pub const MSG_OLDSTDERR: msgtype = 211;
pub const MSG_SHUTDOWN: msgtype = 210;
pub const MSG_SHELL: msgtype = 209;
pub const MSG_RESIZE: msgtype = 208;
pub const MSG_READY: msgtype = 207;
pub const MSG_LOCK: msgtype = 206;
pub const MSG_EXITING: msgtype = 205;
pub const MSG_EXITED: msgtype = 204;
pub const MSG_EXIT: msgtype = 203;
pub const MSG_DETACHKILL: msgtype = 202;
pub const MSG_DETACH: msgtype = 201;
pub const MSG_COMMAND: msgtype = 200;
pub const MSG_IDENTIFY_TERMINFO: msgtype = 112;
pub const MSG_IDENTIFY_LONGFLAGS: msgtype = 111;
pub const MSG_IDENTIFY_STDOUT: msgtype = 110;
pub const MSG_IDENTIFY_FEATURES: msgtype = 109;
pub const MSG_IDENTIFY_CWD: msgtype = 108;
pub const MSG_IDENTIFY_CLIENTPID: msgtype = 107;
pub const MSG_IDENTIFY_DONE: msgtype = 106;
pub const MSG_IDENTIFY_ENVIRON: msgtype = 105;
pub const MSG_IDENTIFY_STDIN: msgtype = 104;
pub const MSG_IDENTIFY_OLDCWD: msgtype = 103;
pub const MSG_IDENTIFY_TTYNAME: msgtype = 102;
pub const MSG_IDENTIFY_TERM: msgtype = 101;
pub const MSG_IDENTIFY_FLAGS: msgtype = 100;
pub const MSG_VERSION: msgtype = 12;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct client {
    pub name: *const i8,
    pub peer: *mut tmuxpeer,
    pub queue: *mut cmdq_list,
    pub windows: client_windows,
    pub control_state: *mut control_state,
    pub pause_age: u_int,
    pub pid: pid_t,
    pub fd: i32,
    pub out_fd: i32,
    pub event: event,
    pub retval: i32,
    pub creation_time: timeval,
    pub activity_time: timeval,
    pub last_activity_time: timeval,
    pub environ: *mut environ,
    pub jobs: *mut format_job_tree,
    pub title: *mut i8,
    pub path: *mut i8,
    pub cwd: *const i8,
    pub term_name: *mut i8,
    pub term_features: i32,
    pub term_type: *mut i8,
    pub term_caps: *mut *mut i8,
    pub term_ncaps: u_int,
    pub ttyname: *mut i8,
    pub tty: tty,
    pub written: size_t,
    pub discarded: size_t,
    pub redraw: size_t,
    pub repeat_timer: event,
    pub click_timer: event,
    pub click_button: u_int,
    pub click_event: mouse_event,
    pub status: status_line,
    pub flags: uint64_t,
    pub exit_type: C2RustUnnamed_31,
    pub exit_msgtype: msgtype,
    pub exit_session: *mut i8,
    pub exit_message: *mut i8,
    pub keytable: *mut key_table,
    pub last_key: key_code,
    pub redraw_panes: uint64_t,
    pub redraw_scrollbars: uint64_t,
    pub message_ignore_keys: i32,
    pub message_ignore_styles: i32,
    pub message_string: *mut i8,
    pub message_timer: event,
    pub prompt_string: *mut i8,
    pub prompt_buffer: *mut utf8_data,
    pub prompt_last: *mut i8,
    pub prompt_index: size_t,
    pub prompt_inputcb: prompt_input_cb,
    pub prompt_freecb: prompt_free_cb,
    pub prompt_data: *mut libc::c_void,
    pub prompt_hindex: [u_int; 4],
    pub prompt_mode: C2RustUnnamed_27,
    pub prompt_saved: *mut utf8_data,
    pub prompt_flags: i32,
    pub prompt_type: prompt_type,
    pub prompt_cursor: i32,
    pub session: *mut session,
    pub last_session: *mut session,
    pub references: i32,
    pub pan_window: *mut libc::c_void,
    pub pan_ox: u_int,
    pub pan_oy: u_int,
    pub overlay_check: overlay_check_cb,
    pub overlay_mode: overlay_mode_cb,
    pub overlay_draw: overlay_draw_cb,
    pub overlay_key: overlay_key_cb,
    pub overlay_free: overlay_free_cb,
    pub overlay_resize: overlay_resize_cb,
    pub overlay_data: *mut libc::c_void,
    pub overlay_timer: event,
    pub files: client_files,
    pub clipboard_panes: *mut u_int,
    pub clipboard_npanes: u_int,
    pub entry: C2RustUnnamed_8,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_8 {
    pub tqe_next: *mut client,
    pub tqe_prev: *mut *mut client,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct client_files {
    pub rbh_root: *mut client_file,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct client_file {
    pub c: *mut client,
    pub peer: *mut tmuxpeer,
    pub tree: *mut client_files,
    pub references: i32,
    pub stream: i32,
    pub path: *mut i8,
    pub buffer: *mut evbuffer,
    pub event: *mut bufferevent,
    pub fd: i32,
    pub error: i32,
    pub closed: i32,
    pub cb: client_file_cb,
    pub data: *mut libc::c_void,
    pub entry: C2RustUnnamed_9,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_9 {
    pub rbe_left: *mut client_file,
    pub rbe_right: *mut client_file,
    pub rbe_parent: *mut client_file,
    pub rbe_color: i32,
}
pub type client_file_cb = Option<
    unsafe extern "C" fn(*mut client, *const i8, i32, i32, *mut evbuffer, *mut libc::c_void) -> (),
>;
pub type overlay_resize_cb = Option<unsafe extern "C" fn(*mut client, *mut libc::c_void) -> ()>;
pub type overlay_free_cb = Option<unsafe extern "C" fn(*mut client, *mut libc::c_void) -> ()>;
pub type overlay_key_cb =
    Option<unsafe extern "C" fn(*mut client, *mut libc::c_void, *mut key_event) -> i32>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct key_event {
    pub key: key_code,
    pub m: mouse_event,
    pub buf: *mut i8,
    pub len: size_t,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct mouse_event {
    pub valid: i32,
    pub ignore: i32,
    pub key: key_code,
    pub statusat: i32,
    pub statuslines: u_int,
    pub x: u_int,
    pub y: u_int,
    pub b: u_int,
    pub lx: u_int,
    pub ly: u_int,
    pub lb: u_int,
    pub ox: u_int,
    pub oy: u_int,
    pub s: i32,
    pub w: i32,
    pub wp: i32,
    pub sgr_type: u_int,
    pub sgr_b: u_int,
}
pub type key_code = u64;
pub type overlay_draw_cb =
    Option<unsafe extern "C" fn(*mut client, *mut libc::c_void, *mut screen_redraw_ctx) -> ()>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct screen_redraw_ctx {
    pub c: *mut client,
    pub statuslines: u_int,
    pub statustop: i32,
    pub pane_status: i32,
    pub pane_lines: pane_lines,
    pub pane_scrollbars: i32,
    pub pane_scrollbars_pos: i32,
    pub no_pane_gc: grid_cell,
    pub no_pane_gc_set: i32,
    pub sx: u_int,
    pub sy: u_int,
    pub ox: u_int,
    pub oy: u_int,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct grid_cell {
    pub data: utf8_data,
    pub attr: u_short,
    pub flags: u_char,
    pub fg: i32,
    pub bg: i32,
    pub us: i32,
    pub link: u_int,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct utf8_data {
    pub data: [u_char; 21],
    pub have: u_char,
    pub size: u_char,
    pub width: u_char,
}
pub type pane_lines = u32;
pub const PANE_LINES_NUMBER: pane_lines = 4;
pub const PANE_LINES_SIMPLE: pane_lines = 3;
pub const PANE_LINES_HEAVY: pane_lines = 2;
pub const PANE_LINES_DOUBLE: pane_lines = 1;
pub const PANE_LINES_SINGLE: pane_lines = 0;
pub type overlay_mode_cb = Option<
    unsafe extern "C" fn(*mut client, *mut libc::c_void, *mut u_int, *mut u_int) -> *mut screen,
>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct screen {
    pub title: *mut i8,
    pub path: *mut i8,
    pub titles: *mut screen_titles,
    pub grid: *mut grid,
    pub cx: u_int,
    pub cy: u_int,
    pub cstyle: screen_cursor_style,
    pub default_cstyle: screen_cursor_style,
    pub ccolour: i32,
    pub default_ccolour: i32,
    pub rupper: u_int,
    pub rlower: u_int,
    pub mode: i32,
    pub default_mode: i32,
    pub saved_cx: u_int,
    pub saved_cy: u_int,
    pub saved_grid: *mut grid,
    pub saved_cell: grid_cell,
    pub saved_flags: i32,
    pub tabs: *mut bitstr_t,
    pub sel: *mut screen_sel,
    pub write_list: *mut screen_write_cline,
    pub hyperlinks: *mut hyperlinks,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct grid {
    pub flags: i32,
    pub sx: u_int,
    pub sy: u_int,
    pub hscrolled: u_int,
    pub hsize: u_int,
    pub hlimit: u_int,
    pub linedata: *mut grid_line,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct grid_line {
    pub celldata: *mut grid_cell_entry,
    pub cellused: u_int,
    pub cellsize: u_int,
    pub extddata: *mut grid_extd_entry,
    pub extdsize: u_int,
    pub flags: i32,
    pub time: time_t,
}
#[derive(Copy, Clone)]
#[repr(C, packed)]
pub struct grid_extd_entry {
    pub data: utf8_char,
    pub attr: u_short,
    pub flags: u_char,
    pub fg: i32,
    pub bg: i32,
    pub us: i32,
    pub link: u_int,
}
pub type utf8_char = u_int;
#[derive(Copy, Clone)]
#[repr(C, packed)]
pub struct grid_cell_entry {
    pub c2rust_unnamed: C2RustUnnamed_10,
    pub flags: u_char,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub union C2RustUnnamed_10 {
    pub offset: u_int,
    pub data: C2RustUnnamed_11,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_11 {
    pub attr: u_char,
    pub fg: u_char,
    pub bg: u_char,
    pub data: u_char,
}
pub type screen_cursor_style = u32;
pub const SCREEN_CURSOR_BAR: screen_cursor_style = 3;
pub const SCREEN_CURSOR_UNDERLINE: screen_cursor_style = 2;
pub const SCREEN_CURSOR_BLOCK: screen_cursor_style = 1;
pub const SCREEN_CURSOR_DEFAULT: screen_cursor_style = 0;
pub type overlay_check_cb = Option<
    unsafe extern "C" fn(
        *mut client,
        *mut libc::c_void,
        u_int,
        u_int,
        u_int,
        *mut overlay_ranges,
    ) -> (),
>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct overlay_ranges {
    pub px: [u_int; 3],
    pub nx: [u_int; 3],
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct session {
    pub id: u_int,
    pub name: *mut i8,
    pub cwd: *const i8,
    pub creation_time: timeval,
    pub last_attached_time: timeval,
    pub activity_time: timeval,
    pub last_activity_time: timeval,
    pub lock_timer: event,
    pub curw: *mut winlink,
    pub lastw: winlink_stack,
    pub windows: winlinks,
    pub statusat: i32,
    pub statuslines: u_int,
    pub options: *mut options,
    pub flags: i32,
    pub attached: u_int,
    pub tio: *mut termios,
    pub environ: *mut environ,
    pub references: i32,
    pub gentry: C2RustUnnamed_13,
    pub entry: C2RustUnnamed_12,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_12 {
    pub rbe_left: *mut session,
    pub rbe_right: *mut session,
    pub rbe_parent: *mut session,
    pub rbe_color: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_13 {
    pub tqe_next: *mut session,
    pub tqe_prev: *mut *mut session,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct winlinks {
    pub rbh_root: *mut winlink,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct winlink {
    pub idx: i32,
    pub session: *mut session,
    pub window: *mut window,
    pub flags: i32,
    pub entry: C2RustUnnamed_16,
    pub wentry: C2RustUnnamed_15,
    pub sentry: C2RustUnnamed_14,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_14 {
    pub tqe_next: *mut winlink,
    pub tqe_prev: *mut *mut winlink,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_15 {
    pub tqe_next: *mut winlink,
    pub tqe_prev: *mut *mut winlink,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_16 {
    pub rbe_left: *mut winlink,
    pub rbe_right: *mut winlink,
    pub rbe_parent: *mut winlink,
    pub rbe_color: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window {
    pub id: u_int,
    pub latest: *mut libc::c_void,
    pub name: *mut i8,
    pub name_event: event,
    pub name_time: timeval,
    pub alerts_timer: event,
    pub offset_timer: event,
    pub activity_time: timeval,
    pub active: *mut window_pane,
    pub last_panes: window_panes,
    pub panes: window_panes,
    pub lastlayout: i32,
    pub layout_root: *mut layout_cell,
    pub saved_layout_root: *mut layout_cell,
    pub old_layout: *mut i8,
    pub sx: u_int,
    pub sy: u_int,
    pub manual_sx: u_int,
    pub manual_sy: u_int,
    pub xpixel: u_int,
    pub ypixel: u_int,
    pub new_sx: u_int,
    pub new_sy: u_int,
    pub new_xpixel: u_int,
    pub new_ypixel: u_int,
    pub fill_character: *mut utf8_data,
    pub flags: i32,
    pub alerts_queued: i32,
    pub alerts_entry: C2RustUnnamed_19,
    pub options: *mut options,
    pub references: u_int,
    pub winlinks: C2RustUnnamed_18,
    pub entry: C2RustUnnamed_17,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_17 {
    pub rbe_left: *mut window,
    pub rbe_right: *mut window,
    pub rbe_parent: *mut window,
    pub rbe_color: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_18 {
    pub tqh_first: *mut winlink,
    pub tqh_last: *mut *mut winlink,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_19 {
    pub tqe_next: *mut window,
    pub tqe_prev: *mut *mut window,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct layout_cell {
    pub type_0: layout_type,
    pub parent: *mut layout_cell,
    pub sx: u_int,
    pub sy: u_int,
    pub xoff: u_int,
    pub yoff: u_int,
    pub wp: *mut window_pane,
    pub cells: layout_cells,
    pub entry: C2RustUnnamed_20,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_20 {
    pub tqe_next: *mut layout_cell,
    pub tqe_prev: *mut *mut layout_cell,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct layout_cells {
    pub tqh_first: *mut layout_cell,
    pub tqh_last: *mut *mut layout_cell,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_pane {
    pub id: u_int,
    pub active_point: u_int,
    pub window: *mut window,
    pub options: *mut options,
    pub layout_cell: *mut layout_cell,
    pub saved_layout_cell: *mut layout_cell,
    pub sx: u_int,
    pub sy: u_int,
    pub xoff: u_int,
    pub yoff: u_int,
    pub flags: i32,
    pub sb_slider_y: u_int,
    pub sb_slider_h: u_int,
    pub argc: i32,
    pub argv: *mut *mut i8,
    pub shell: *mut i8,
    pub cwd: *mut i8,
    pub pid: pid_t,
    pub tty: [i8; 32],
    pub status: i32,
    pub dead_time: timeval,
    pub fd: i32,
    pub event: *mut bufferevent,
    pub offset: window_pane_offset,
    pub base_offset: size_t,
    pub resize_queue: window_pane_resizes,
    pub resize_timer: event,
    pub ictx: *mut input_ctx,
    pub cached_gc: grid_cell,
    pub cached_active_gc: grid_cell,
    pub palette: colour_palette,
    pub pipe_fd: i32,
    pub pipe_event: *mut bufferevent,
    pub pipe_offset: window_pane_offset,
    pub screen: *mut screen,
    pub base: screen,
    pub status_screen: screen,
    pub status_size: size_t,
    pub modes: C2RustUnnamed_24,
    pub searchstr: *mut i8,
    pub searchregex: i32,
    pub border_gc_set: i32,
    pub border_gc: grid_cell,
    pub control_bg: i32,
    pub control_fg: i32,
    pub scrollbar_style: style,
    pub entry: C2RustUnnamed_23,
    pub sentry: C2RustUnnamed_22,
    pub tree_entry: C2RustUnnamed_21,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_21 {
    pub rbe_left: *mut window_pane,
    pub rbe_right: *mut window_pane,
    pub rbe_parent: *mut window_pane,
    pub rbe_color: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_22 {
    pub tqe_next: *mut window_pane,
    pub tqe_prev: *mut *mut window_pane,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_23 {
    pub tqe_next: *mut window_pane,
    pub tqe_prev: *mut *mut window_pane,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct style {
    pub gc: grid_cell,
    pub ignore: i32,
    pub fill: i32,
    pub align: style_align,
    pub list: style_list,
    pub range_type: style_range_type,
    pub range_argument: u_int,
    pub range_string: [i8; 16],
    pub width: i32,
    pub pad: i32,
    pub default_type: style_default_type,
}
pub type style_default_type = u32;
pub const STYLE_DEFAULT_POP: style_default_type = 2;
pub const STYLE_DEFAULT_PUSH: style_default_type = 1;
pub const STYLE_DEFAULT_BASE: style_default_type = 0;
pub type style_range_type = u32;
pub const STYLE_RANGE_USER: style_range_type = 6;
pub const STYLE_RANGE_SESSION: style_range_type = 5;
pub const STYLE_RANGE_WINDOW: style_range_type = 4;
pub const STYLE_RANGE_PANE: style_range_type = 3;
pub const STYLE_RANGE_RIGHT: style_range_type = 2;
pub const STYLE_RANGE_LEFT: style_range_type = 1;
pub const STYLE_RANGE_NONE: style_range_type = 0;
pub type style_list = u32;
pub const STYLE_LIST_RIGHT_MARKER: style_list = 4;
pub const STYLE_LIST_LEFT_MARKER: style_list = 3;
pub const STYLE_LIST_FOCUS: style_list = 2;
pub const STYLE_LIST_ON: style_list = 1;
pub const STYLE_LIST_OFF: style_list = 0;
pub type style_align = u32;
pub const STYLE_ALIGN_ABSOLUTE_CENTRE: style_align = 4;
pub const STYLE_ALIGN_RIGHT: style_align = 3;
pub const STYLE_ALIGN_CENTRE: style_align = 2;
pub const STYLE_ALIGN_LEFT: style_align = 1;
pub const STYLE_ALIGN_DEFAULT: style_align = 0;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_24 {
    pub tqh_first: *mut window_mode_entry,
    pub tqh_last: *mut *mut window_mode_entry,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_mode_entry {
    pub wp: *mut window_pane,
    pub swp: *mut window_pane,
    pub mode: *const window_mode,
    pub data: *mut libc::c_void,
    pub screen: *mut screen,
    pub prefix: u_int,
    pub entry: C2RustUnnamed_25,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_25 {
    pub tqe_next: *mut window_mode_entry,
    pub tqe_prev: *mut *mut window_mode_entry,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_mode {
    pub name: *const i8,
    pub default_format: *const i8,
    pub init: Option<
        unsafe extern "C" fn(*mut window_mode_entry, *mut cmd_find_state, *mut args) -> *mut screen,
    >,
    pub free: Option<unsafe extern "C" fn(*mut window_mode_entry) -> ()>,
    pub resize: Option<unsafe extern "C" fn(*mut window_mode_entry, u_int, u_int) -> ()>,
    pub update: Option<unsafe extern "C" fn(*mut window_mode_entry) -> ()>,
    pub key: Option<
        unsafe extern "C" fn(
            *mut window_mode_entry,
            *mut client,
            *mut session,
            *mut winlink,
            key_code,
            *mut mouse_event,
        ) -> (),
    >,
    pub key_table: Option<unsafe extern "C" fn(*mut window_mode_entry) -> *const i8>,
    pub command: Option<
        unsafe extern "C" fn(
            *mut window_mode_entry,
            *mut client,
            *mut session,
            *mut winlink,
            *mut args,
            *mut mouse_event,
        ) -> (),
    >,
    pub formats: Option<unsafe extern "C" fn(*mut window_mode_entry, *mut format_tree) -> ()>,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct cmd_find_state {
    pub flags: i32,
    pub current: *mut cmd_find_state,
    pub s: *mut session,
    pub wl: *mut winlink,
    pub w: *mut window,
    pub wp: *mut window_pane,
    pub idx: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_pane_offset {
    pub used: size_t,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct colour_palette {
    pub fg: i32,
    pub bg: i32,
    pub palette: *mut i32,
    pub default_palette: *mut i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_pane_resizes {
    pub tqh_first: *mut window_pane_resize,
    pub tqh_last: *mut *mut window_pane_resize,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_pane_resize {
    pub sx: u_int,
    pub sy: u_int,
    pub osx: u_int,
    pub osy: u_int,
    pub entry: C2RustUnnamed_26,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_26 {
    pub tqe_next: *mut window_pane_resize,
    pub tqe_prev: *mut *mut window_pane_resize,
}
pub type layout_type = u32;
pub const LAYOUT_WINDOWPANE: layout_type = 2;
pub const LAYOUT_TOPBOTTOM: layout_type = 1;
pub const LAYOUT_LEFTRIGHT: layout_type = 0;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct window_panes {
    pub tqh_first: *mut window_pane,
    pub tqh_last: *mut *mut window_pane,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct winlink_stack {
    pub tqh_first: *mut winlink,
    pub tqh_last: *mut *mut winlink,
}
pub type prompt_type = u32;
pub const PROMPT_TYPE_INVALID: prompt_type = 255;
pub const PROMPT_TYPE_WINDOW_TARGET: prompt_type = 3;
pub const PROMPT_TYPE_TARGET: prompt_type = 2;
pub const PROMPT_TYPE_SEARCH: prompt_type = 1;
pub const PROMPT_TYPE_COMMAND: prompt_type = 0;
pub type C2RustUnnamed_27 = u32;
pub const PROMPT_COMMAND: C2RustUnnamed_27 = 1;
pub const PROMPT_ENTRY: C2RustUnnamed_27 = 0;
pub type prompt_free_cb = Option<unsafe extern "C" fn(*mut libc::c_void) -> ()>;
pub type prompt_input_cb =
    Option<unsafe extern "C" fn(*mut client, *mut libc::c_void, *const i8, i32) -> i32>;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct key_table {
    pub name: *const i8,
    pub activity_time: timeval,
    pub key_bindings: key_bindings,
    pub default_key_bindings: key_bindings,
    pub references: u_int,
    pub entry: C2RustUnnamed_28,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_28 {
    pub rbe_left: *mut key_table,
    pub rbe_right: *mut key_table,
    pub rbe_parent: *mut key_table,
    pub rbe_color: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct key_bindings {
    pub rbh_root: *mut key_binding,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct key_binding {
    pub key: key_code,
    pub cmdlist: *mut cmd_list,
    pub note: *const i8,
    pub flags: i32,
    pub entry: C2RustUnnamed_29,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_29 {
    pub rbe_left: *mut key_binding,
    pub rbe_right: *mut key_binding,
    pub rbe_parent: *mut key_binding,
    pub rbe_color: i32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct cmd_list {
    pub references: i32,
    pub group: u_int,
    pub list: *mut cmds,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct cmds {
    pub tqh_first: *mut cmd,
    pub tqh_last: *mut *mut cmd,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct cmd {
    pub entry: *const cmd_entry,
    pub args: *mut args,
    pub group: u_int,
    pub file: *mut i8,
    pub line: u_int,
    pub qentry: C2RustUnnamed_30,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_30 {
    pub tqe_next: *mut cmd,
    pub tqe_prev: *mut *mut cmd,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct cmd_entry {
    pub name: *const i8,
    pub alias: *const i8,
    pub args: args_parse,
    pub usage: *const i8,
    pub source: cmd_entry_flag,
    pub target: cmd_entry_flag,
    pub flags: i32,
    pub exec: Option<unsafe extern "C" fn(*mut cmd, *mut cmdq_item) -> cmd_retval>,
}
pub type cmd_retval = i32;
pub const CMD_RETURN_STOP: cmd_retval = 2;
pub const CMD_RETURN_WAIT: cmd_retval = 1;
pub const CMD_RETURN_NORMAL: cmd_retval = 0;
pub const CMD_RETURN_ERROR: cmd_retval = -1;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct cmd_entry_flag {
    pub flag: i8,
    pub type_0: cmd_find_type,
    pub flags: i32,
}
pub type cmd_find_type = u32;
pub const CMD_FIND_SESSION: cmd_find_type = 2;
pub const CMD_FIND_WINDOW: cmd_find_type = 1;
pub const CMD_FIND_PANE: cmd_find_type = 0;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct args_parse {
    pub template: *const i8,
    pub lower: i32,
    pub upper: i32,
    pub cb: args_parse_cb,
}
pub type args_parse_cb =
    Option<unsafe extern "C" fn(*mut args, u_int, *mut *mut i8) -> args_parse_type>;
pub type args_parse_type = u32;
pub const ARGS_PARSE_COMMANDS: args_parse_type = 3;
pub const ARGS_PARSE_COMMANDS_OR_STRING: args_parse_type = 2;
pub const ARGS_PARSE_STRING: args_parse_type = 1;
pub const ARGS_PARSE_INVALID: args_parse_type = 0;
pub type C2RustUnnamed_31 = u32;
pub const CLIENT_EXIT_DETACH: C2RustUnnamed_31 = 2;
pub const CLIENT_EXIT_SHUTDOWN: C2RustUnnamed_31 = 1;
pub const CLIENT_EXIT_RETURN: C2RustUnnamed_31 = 0;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct status_line {
    pub timer: event,
    pub screen: screen,
    pub active: *mut screen,
    pub references: i32,
    pub style: grid_cell,
    pub entries: [status_line_entry; 5],
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct status_line_entry {
    pub expanded: *mut i8,
    pub ranges: style_ranges,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct style_ranges {
    pub tqh_first: *mut style_range,
    pub tqh_last: *mut *mut style_range,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct style_range {
    pub type_0: style_range_type,
    pub argument: u_int,
    pub string: [i8; 16],
    pub start: u_int,
    pub end: u_int,
    pub entry: C2RustUnnamed_32,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_32 {
    pub tqe_next: *mut style_range,
    pub tqe_prev: *mut *mut style_range,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct tty {
    pub client: *mut client,
    pub start_timer: event,
    pub clipboard_timer: event,
    pub last_requests: time_t,
    pub sx: u_int,
    pub sy: u_int,
    pub xpixel: u_int,
    pub ypixel: u_int,
    pub cx: u_int,
    pub cy: u_int,
    pub cstyle: screen_cursor_style,
    pub ccolour: i32,
    pub oflag: i32,
    pub oox: u_int,
    pub ooy: u_int,
    pub osx: u_int,
    pub osy: u_int,
    pub mode: i32,
    pub fg: i32,
    pub bg: i32,
    pub rlower: u_int,
    pub rupper: u_int,
    pub rleft: u_int,
    pub rright: u_int,
    pub event_in: event,
    pub in_0: *mut evbuffer,
    pub event_out: event,
    pub out: *mut evbuffer,
    pub timer: event,
    pub discarded: size_t,
    pub tio: termios,
    pub cell: grid_cell,
    pub last_cell: grid_cell,
    pub flags: i32,
    pub term: *mut tty_term,
    pub mouse_last_x: u_int,
    pub mouse_last_y: u_int,
    pub mouse_last_b: u_int,
    pub mouse_drag_flag: i32,
    pub mouse_scrolling_flag: i32,
    pub mouse_slider_mpos: i32,
    pub mouse_drag_update: Option<unsafe extern "C" fn(*mut client, *mut mouse_event) -> ()>,
    pub mouse_drag_release: Option<unsafe extern "C" fn(*mut client, *mut mouse_event) -> ()>,
    pub key_timer: event,
    pub key_tree: *mut tty_key,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct tty_term {
    pub name: *mut i8,
    pub tty: *mut tty,
    pub features: i32,
    pub acs: [[i8; 2]; 256],
    pub codes: *mut tty_code,
    pub flags: i32,
    pub entry: C2RustUnnamed_33,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_33 {
    pub le_next: *mut tty_term,
    pub le_prev: *mut *mut tty_term,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct client_windows {
    pub rbh_root: *mut client_window,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct client_window {
    pub window: u_int,
    pub pane: *mut window_pane,
    pub sx: u_int,
    pub sy: u_int,
    pub entry: C2RustUnnamed_34,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_34 {
    pub rbe_left: *mut client_window,
    pub rbe_right: *mut client_window,
    pub rbe_parent: *mut client_window,
    pub rbe_color: i32,
}
pub type args_type = u32;
pub const ARGS_COMMANDS: args_type = 2;
pub const ARGS_STRING: args_type = 1;
pub const ARGS_NONE: args_type = 0;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct args_value {
    pub type_0: args_type,
    pub c2rust_unnamed: C2RustUnnamed_36,
    pub cached: *mut i8,
    pub entry: C2RustUnnamed_35,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_35 {
    pub tqe_next: *mut args_value,
    pub tqe_prev: *mut *mut args_value,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub union C2RustUnnamed_36 {
    pub string: *mut i8,
    pub cmdlist: *mut cmd_list,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct options_array {
    pub rbh_root: *mut options_array_item,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub union options_value {
    pub string: *mut i8,
    pub number: i64,
    pub style: style,
    pub array: options_array,
    pub cmdlist: *mut cmd_list,
}
#[no_mangle]
pub static mut cmd_table: [*const cmd_entry; 91] = unsafe {
    [
        &cmd_attach_session_entry as *const cmd_entry,
        &cmd_bind_key_entry as *const cmd_entry,
        &cmd_break_pane_entry as *const cmd_entry,
        &cmd_capture_pane_entry as *const cmd_entry,
        &cmd_choose_buffer_entry as *const cmd_entry,
        &cmd_choose_client_entry as *const cmd_entry,
        &cmd_choose_tree_entry as *const cmd_entry,
        &cmd_clear_history_entry as *const cmd_entry,
        &cmd_clear_prompt_history_entry as *const cmd_entry,
        &cmd_clock_mode_entry as *const cmd_entry,
        &cmd_command_prompt_entry as *const cmd_entry,
        &cmd_confirm_before_entry as *const cmd_entry,
        &cmd_copy_mode_entry as *const cmd_entry,
        &cmd_customize_mode_entry as *const cmd_entry,
        &cmd_delete_buffer_entry as *const cmd_entry,
        &cmd_detach_client_entry as *const cmd_entry,
        &cmd_display_menu_entry as *const cmd_entry,
        &cmd_display_message_entry as *const cmd_entry,
        &cmd_display_popup_entry as *const cmd_entry,
        &cmd_display_panes_entry as *const cmd_entry,
        &cmd_find_window_entry as *const cmd_entry,
        &cmd_has_session_entry as *const cmd_entry,
        &cmd_if_shell_entry as *const cmd_entry,
        &cmd_join_pane_entry as *const cmd_entry,
        &cmd_kill_pane_entry as *const cmd_entry,
        &cmd_kill_server_entry as *const cmd_entry,
        &cmd_kill_session_entry as *const cmd_entry,
        &cmd_kill_window_entry as *const cmd_entry,
        &cmd_last_pane_entry as *const cmd_entry,
        &cmd_last_window_entry as *const cmd_entry,
        &cmd_link_window_entry as *const cmd_entry,
        &cmd_list_buffers_entry as *const cmd_entry,
        &cmd_list_clients_entry as *const cmd_entry,
        &cmd_list_commands_entry as *const cmd_entry,
        &cmd_list_keys_entry as *const cmd_entry,
        &cmd_list_panes_entry as *const cmd_entry,
        &cmd_list_sessions_entry as *const cmd_entry,
        &cmd_list_windows_entry as *const cmd_entry,
        &cmd_load_buffer_entry as *const cmd_entry,
        &cmd_lock_client_entry as *const cmd_entry,
        &cmd_lock_server_entry as *const cmd_entry,
        &cmd_lock_session_entry as *const cmd_entry,
        &cmd_move_pane_entry as *const cmd_entry,
        &cmd_move_window_entry as *const cmd_entry,
        &cmd_new_session_entry as *const cmd_entry,
        &cmd_new_window_entry as *const cmd_entry,
        &cmd_next_layout_entry as *const cmd_entry,
        &cmd_next_window_entry as *const cmd_entry,
        &cmd_paste_buffer_entry as *const cmd_entry,
        &cmd_pipe_pane_entry as *const cmd_entry,
        &cmd_previous_layout_entry as *const cmd_entry,
        &cmd_previous_window_entry as *const cmd_entry,
        &cmd_refresh_client_entry as *const cmd_entry,
        &cmd_rename_session_entry as *const cmd_entry,
        &cmd_rename_window_entry as *const cmd_entry,
        &cmd_resize_pane_entry as *const cmd_entry,
        &cmd_resize_window_entry as *const cmd_entry,
        &cmd_respawn_pane_entry as *const cmd_entry,
        &cmd_respawn_window_entry as *const cmd_entry,
        &cmd_rotate_window_entry as *const cmd_entry,
        &cmd_run_shell_entry as *const cmd_entry,
        &cmd_save_buffer_entry as *const cmd_entry,
        &cmd_select_layout_entry as *const cmd_entry,
        &cmd_select_pane_entry as *const cmd_entry,
        &cmd_select_window_entry as *const cmd_entry,
        &cmd_send_keys_entry as *const cmd_entry,
        &cmd_send_prefix_entry as *const cmd_entry,
        &cmd_server_access_entry as *const cmd_entry,
        &cmd_set_buffer_entry as *const cmd_entry,
        &cmd_set_environment_entry as *const cmd_entry,
        &cmd_set_hook_entry as *const cmd_entry,
        &cmd_set_option_entry as *const cmd_entry,
        &cmd_set_window_option_entry as *const cmd_entry,
        &cmd_show_buffer_entry as *const cmd_entry,
        &cmd_show_environment_entry as *const cmd_entry,
        &cmd_show_hooks_entry as *const cmd_entry,
        &cmd_show_messages_entry as *const cmd_entry,
        &cmd_show_options_entry as *const cmd_entry,
        &cmd_show_prompt_history_entry as *const cmd_entry,
        &cmd_show_window_options_entry as *const cmd_entry,
        &cmd_source_file_entry as *const cmd_entry,
        &cmd_split_window_entry as *const cmd_entry,
        &cmd_start_server_entry as *const cmd_entry,
        &cmd_suspend_client_entry as *const cmd_entry,
        &cmd_swap_pane_entry as *const cmd_entry,
        &cmd_swap_window_entry as *const cmd_entry,
        &cmd_switch_client_entry as *const cmd_entry,
        &cmd_unbind_key_entry as *const cmd_entry,
        &cmd_unlink_window_entry as *const cmd_entry,
        &cmd_wait_for_entry as *const cmd_entry,
        0 as *const cmd_entry,
    ]
};
static mut cmd_list_next_group: u_int = 1 as i32 as u_int;
#[no_mangle]
pub unsafe extern "C" fn cmd_log_argv(
    mut argc: i32,
    mut argv: *mut *mut i8,
    mut fmt: *const i8,
    mut args: ...
) {
    let mut prefix: *mut i8 = std::ptr::null_mut::<i8>();
    let mut ap: ::core::ffi::VaListImpl;
    let mut i: i32 = 0;
    ap = args.clone();
    xvasprintf(&mut prefix, fmt, ap.as_va_list());
    i = 0 as i32;
    while i < argc {
        log_debug(
            b"%s: argv[%d]=%s\0" as *const u8 as *const i8,
            prefix,
            i,
            *argv.offset(i as isize),
        );
        i += 1;
    }
    free(prefix as *mut libc::c_void);
}
#[no_mangle]
pub extern "C" fn cmd_prepend_argv(
    mut argc: *mut i32,
    mut argv: *mut *mut *mut i8,
    mut arg: *const i8,
) {
    let mut new_argv: *mut *mut i8 = std::ptr::null_mut::<*mut i8>();
    let mut i: i32 = 0;
    new_argv = (unsafe {
        xreallocarray(
            std::ptr::null_mut::<libc::c_void>(),
            (*argc + 1 as i32) as size_t,
            ::core::mem::size_of::<*mut i8>() as u64,
        )
    }) as *mut *mut i8;
    let fresh0 = unsafe { &mut (*new_argv.offset(0 as i32 as isize)) };
    *fresh0 = unsafe { xstrdup(arg) };
    i = 0 as i32;
    while i < (unsafe { *argc }) {
        let fresh1 = unsafe { &mut (*new_argv.offset((1 as i32 + i) as isize)) };
        *fresh1 = unsafe { *(*argv).offset(i as isize) };
        i += 1;
    }
    (unsafe { free(*argv as *mut libc::c_void) });
    (unsafe { *argv = new_argv });
    (unsafe { *argc += 1 });
}
#[no_mangle]
pub extern "C" fn cmd_append_argv(
    mut argc: *mut i32,
    mut argv: *mut *mut *mut i8,
    mut arg: *const i8,
) {
    (unsafe {
        *argv = xreallocarray(
            *argv as *mut libc::c_void,
            (*argc + 1 as i32) as size_t,
            ::core::mem::size_of::<*mut i8>() as u64,
        ) as *mut *mut i8
    });
    let fresh2 = unsafe { *argc };
    (unsafe { *argc = *argc + 1 });
    let fresh3 = unsafe { &mut (*(*argv).offset(fresh2 as isize)) };
    *fresh3 = unsafe { xstrdup(arg) };
}
#[no_mangle]
pub extern "C" fn cmd_pack_argv(
    mut argc: i32,
    mut argv: *mut *mut i8,
    mut buf: *mut i8,
    mut len: size_t,
) -> i32 {
    let mut arglen: size_t = 0;
    let mut i: i32 = 0;
    if argc == 0 as i32 {
        return 0 as i32;
    }
    (unsafe {
        cmd_log_argv(
            argc,
            argv,
            b"%s\0" as *const u8 as *const i8,
            (*::core::mem::transmute::<&[u8; 14], &[i8; 14]>(b"cmd_pack_argv\0")).as_ptr(),
        )
    });
    (unsafe { *buf = '\0' as i32 as i8 });
    i = 0 as i32;
    while i < argc {
        if (unsafe { strlcpy(buf, *argv.offset(i as isize), len) }) >= len {
            return -(1 as i32);
        }
        arglen = (unsafe { strlen(*argv.offset(i as isize)) }).wrapping_add(1 as i32 as u64);
        buf = unsafe { buf.offset(arglen as isize) };
        len = (len as u64).wrapping_sub(arglen) as size_t as size_t;
        i += 1;
    }
    return 0 as i32;
}
#[no_mangle]
pub extern "C" fn cmd_unpack_argv(
    mut buf: *mut i8,
    mut len: size_t,
    mut argc: i32,
    mut argv: *mut *mut *mut i8,
) -> i32 {
    let mut i: i32 = 0;
    let mut arglen: size_t = 0;
    if argc == 0 as i32 {
        return 0 as i32;
    }
    (unsafe {
        *argv = xcalloc(argc as size_t, ::core::mem::size_of::<*mut i8>() as u64) as *mut *mut i8
    });
    (unsafe { *buf.offset(len.wrapping_sub(1 as i32 as u64) as isize) = '\0' as i32 as i8 });
    i = 0 as i32;
    while i < argc {
        if len == 0 as i32 as u64 {
            cmd_free_argv(argc, unsafe { *argv });
            return -(1 as i32);
        }
        arglen = (unsafe { strlen(buf) }).wrapping_add(1 as i32 as u64);
        let fresh4 = unsafe { &mut (*(*argv).offset(i as isize)) };
        *fresh4 = unsafe { xstrdup(buf) };
        buf = unsafe { buf.offset(arglen as isize) };
        len = (len as u64).wrapping_sub(arglen) as size_t as size_t;
        i += 1;
    }
    (unsafe {
        cmd_log_argv(
            argc,
            *argv,
            b"%s\0" as *const u8 as *const i8,
            (*::core::mem::transmute::<&[u8; 16], &[i8; 16]>(b"cmd_unpack_argv\0")).as_ptr(),
        )
    });
    return 0 as i32;
}
#[no_mangle]
pub extern "C" fn cmd_copy_argv(mut argc: i32, mut argv: *mut *mut i8) -> *mut *mut i8 {
    let mut new_argv: *mut *mut i8 = std::ptr::null_mut::<*mut i8>();
    let mut i: i32 = 0;
    if argc == 0 as i32 {
        return std::ptr::null_mut::<*mut i8>();
    }
    new_argv = (unsafe {
        xcalloc(
            (argc + 1 as i32) as size_t,
            ::core::mem::size_of::<*mut i8>() as u64,
        )
    }) as *mut *mut i8;
    i = 0 as i32;
    while i < argc {
        if !(unsafe { *argv.offset(i as isize) }).is_null() {
            let fresh5 = unsafe { &mut (*new_argv.offset(i as isize)) };
            *fresh5 = unsafe { xstrdup(*argv.offset(i as isize)) };
        }
        i += 1;
    }
    return new_argv;
}
#[no_mangle]
pub extern "C" fn cmd_free_argv(mut argc: i32, mut argv: *mut *mut i8) {
    let mut i: i32 = 0;
    if argc == 0 as i32 {
        return;
    }
    i = 0 as i32;
    while i < argc {
        (unsafe { free(*argv.offset(i as isize) as *mut libc::c_void) });
        i += 1;
    }
    (unsafe { free(argv as *mut libc::c_void) });
}
#[no_mangle]
pub extern "C" fn cmd_stringify_argv(mut argc: i32, mut argv: *mut *mut i8) -> *mut i8 {
    let mut buf: *mut i8 = std::ptr::null_mut::<i8>();
    let mut s: *mut i8 = std::ptr::null_mut::<i8>();
    let mut len: size_t = 0 as i32 as size_t;
    let mut i: i32 = 0;
    if argc == 0 as i32 {
        return unsafe { xstrdup(b"\0" as *const u8 as *const i8) };
    }
    i = 0 as i32;
    while i < argc {
        s = unsafe { args_escape(*argv.offset(i as isize)) };
        (unsafe {
            log_debug(
                b"%s: %u %s = %s\0" as *const u8 as *const i8,
                (*::core::mem::transmute::<&[u8; 19], &[i8; 19]>(b"cmd_stringify_argv\0")).as_ptr(),
                i,
                *argv.offset(i as isize),
                s,
            )
        });
        len = (len as u64).wrapping_add((unsafe { strlen(s) }).wrapping_add(1 as i32 as u64))
            as size_t as size_t;
        buf = (unsafe { xrealloc(buf as *mut libc::c_void, len) }) as *mut i8;
        if i == 0 as i32 {
            (unsafe { *buf = '\0' as i32 as i8 });
        } else {
            (unsafe { strlcat(buf, b" \0" as *const u8 as *const i8, len) });
        }
        (unsafe { strlcat(buf, s, len) });
        (unsafe { free(s as *mut libc::c_void) });
        i += 1;
    }
    return buf;
}
#[no_mangle]
pub extern "C" fn cmd_get_entry(mut cmd: *mut cmd) -> *const cmd_entry {
    return unsafe { (*cmd).entry };
}
#[no_mangle]
pub extern "C" fn cmd_get_args(mut cmd: *mut cmd) -> *mut args {
    return unsafe { (*cmd).args };
}
#[no_mangle]
pub extern "C" fn cmd_get_group(mut cmd: *mut cmd) -> u_int {
    return unsafe { (*cmd).group };
}
#[no_mangle]
pub extern "C" fn cmd_get_source(
    mut cmd: *mut cmd,
    mut file: *mut *const i8,
    mut line: *mut u_int,
) {
    if !file.is_null() {
        (unsafe { *file = (*cmd).file });
    }
    if !line.is_null() {
        (unsafe { *line = (*cmd).line });
    }
}
#[no_mangle]
pub extern "C" fn cmd_get_alias(mut name: *const i8) -> *mut i8 {
    let mut o: *mut options_entry = std::ptr::null_mut::<options_entry>();
    let mut a: *mut options_array_item = std::ptr::null_mut::<options_array_item>();
    let mut ov: *mut options_value = std::ptr::null_mut::<options_value>();
    let mut wanted: size_t = 0;
    let mut n: size_t = 0;
    let mut equals: *const i8 = std::ptr::null::<i8>();
    o = unsafe { options_get_only(global_options, b"command-alias\0" as *const u8 as *const i8) };
    if o.is_null() {
        return std::ptr::null_mut::<i8>();
    }
    wanted = unsafe { strlen(name) };
    a = unsafe { options_array_first(o) };
    while !a.is_null() {
        ov = unsafe { options_array_item_value(a) };
        equals = unsafe { strchr((*ov).string, '=' as i32) };
        if !equals.is_null() {
            n = (unsafe { equals.offset_from((*ov).string) }) as i64 as size_t;
            if n == wanted && (unsafe { strncmp(name, (*ov).string, n) }) == 0 as i32 {
                return unsafe { xstrdup(equals.offset(1 as i32 as isize)) };
            }
        }
        a = unsafe { options_array_next(a) };
    }
    return std::ptr::null_mut::<i8>();
}
extern "C" fn cmd_find(mut name: *const i8, mut cause: *mut *mut i8) -> *const cmd_entry {
    let mut loop_0: *mut *const cmd_entry = std::ptr::null_mut::<*const cmd_entry>();
    let mut entry: *const cmd_entry = std::ptr::null::<cmd_entry>();
    let mut found: *const cmd_entry = std::ptr::null::<cmd_entry>();
    let mut ambiguous: i32 = 0;
    let mut s: [i8; 8192] = [0; 8192];
    ambiguous = 0 as i32;
    loop_0 = unsafe { cmd_table.as_mut_ptr() };
    while !(unsafe { *loop_0 }).is_null() {
        entry = unsafe { *loop_0 };
        if !(unsafe { (*entry).alias }).is_null()
            && (unsafe { strcmp((*entry).alias, name) }) == 0 as i32
        {
            ambiguous = 0 as i32;
            found = entry;
            break;
        } else {
            if (unsafe { strncmp((*entry).name, name, strlen(name)) }) == 0 as i32 {
                if !found.is_null() {
                    ambiguous = 1 as i32;
                }
                found = entry;
                if (unsafe { strcmp((*entry).name, name) }) == 0 as i32 {
                    break;
                }
            }
            loop_0 = unsafe { loop_0.offset(1) };
        }
    }
    if ambiguous != 0 {
        (unsafe { *s.as_mut_ptr() = '\0' as i32 as i8 });
        loop_0 = unsafe { cmd_table.as_mut_ptr() };
        while !(unsafe { *loop_0 }).is_null() {
            entry = unsafe { *loop_0 };
            if (unsafe { strncmp((*entry).name, name, strlen(name)) }) == 0 as i32 {
                if (unsafe {
                    strlcat(
                        s.as_mut_ptr(),
                        (*entry).name,
                        ::core::mem::size_of::<[i8; 8192]>() as u64,
                    )
                }) >= ::core::mem::size_of::<[i8; 8192]>() as u64
                {
                    break;
                }
                if (unsafe {
                    strlcat(
                        s.as_mut_ptr(),
                        b", \0" as *const u8 as *const i8,
                        ::core::mem::size_of::<[i8; 8192]>() as u64,
                    )
                }) >= ::core::mem::size_of::<[i8; 8192]>() as u64
                {
                    break;
                }
            }
            loop_0 = unsafe { loop_0.offset(1) };
        }
        s[(unsafe { strlen(s.as_mut_ptr()) }).wrapping_sub(2 as i32 as u64) as usize] =
            '\0' as i32 as i8;
        (unsafe {
            xasprintf(
                cause,
                b"ambiguous command: %s, could be: %s\0" as *const u8 as *const i8,
                name,
                s.as_mut_ptr(),
            )
        });
        return std::ptr::null::<cmd_entry>();
    } else {
        if found.is_null() {
            (unsafe {
                xasprintf(
                    cause,
                    b"unknown command: %s\0" as *const u8 as *const i8,
                    name,
                )
            });
            return std::ptr::null::<cmd_entry>();
        }
        return found;
    };
}
#[no_mangle]
pub extern "C" fn cmd_parse(
    mut values: *mut args_value,
    mut count: u_int,
    mut file: *const i8,
    mut line: u_int,
    mut cause: *mut *mut i8,
) -> *mut cmd {
    let mut entry: *const cmd_entry = std::ptr::null::<cmd_entry>();
    let mut cmd: *mut cmd = std::ptr::null_mut::<cmd>();
    let mut args: *mut args = std::ptr::null_mut::<args>();
    let mut error: *mut i8 = std::ptr::null_mut::<i8>();
    if count == 0 as i32 as u32
        || (unsafe { (*values.offset(0 as i32 as isize)).type_0 }) as u32
            != ARGS_STRING as i32 as u32
    {
        (unsafe { xasprintf(cause, b"no command\0" as *const u8 as *const i8) });
        return std::ptr::null_mut::<cmd>();
    }
    entry = cmd_find(
        unsafe { (*values.offset(0 as i32 as isize)).c2rust_unnamed.string },
        cause,
    );
    if entry.is_null() {
        return std::ptr::null_mut::<cmd>();
    }
    args = unsafe { args_parse(&(*entry).args, values, count, &mut error) };
    if args.is_null() && error.is_null() {
        (unsafe {
            xasprintf(
                cause,
                b"usage: %s %s\0" as *const u8 as *const i8,
                (*entry).name,
                (*entry).usage,
            )
        });
        return std::ptr::null_mut::<cmd>();
    }
    if args.is_null() {
        (unsafe {
            xasprintf(
                cause,
                b"command %s: %s\0" as *const u8 as *const i8,
                (*entry).name,
                error,
            )
        });
        (unsafe { free(error as *mut libc::c_void) });
        return std::ptr::null_mut::<cmd>();
    }
    cmd =
        (unsafe { xcalloc(1 as i32 as size_t, ::core::mem::size_of::<cmd>() as u64) }) as *mut cmd;
    (unsafe { (*cmd).entry = entry });
    (unsafe { (*cmd).args = args });
    if !file.is_null() {
        (unsafe { (*cmd).file = xstrdup(file) });
    }
    (unsafe { (*cmd).line = line });
    return cmd;
}
#[no_mangle]
pub extern "C" fn cmd_free(mut cmd: *mut cmd) {
    (unsafe { free((*cmd).file as *mut libc::c_void) });
    (unsafe { args_free((*cmd).args) });
    (unsafe { free(cmd as *mut libc::c_void) });
}
#[no_mangle]
pub extern "C" fn cmd_copy(mut cmd: *mut cmd, mut argc: i32, mut argv: *mut *mut i8) -> *mut cmd {
    let mut new_cmd: *mut cmd = std::ptr::null_mut::<cmd>();
    new_cmd =
        (unsafe { xcalloc(1 as i32 as size_t, ::core::mem::size_of::<cmd>() as u64) }) as *mut cmd;
    (unsafe { (*new_cmd).entry = (*cmd).entry });
    (unsafe { (*new_cmd).args = args_copy((*cmd).args, argc, argv) });
    if !(unsafe { (*cmd).file }).is_null() {
        (unsafe { (*new_cmd).file = xstrdup((*cmd).file) });
    }
    (unsafe { (*new_cmd).line = (*cmd).line });
    return new_cmd;
}
#[no_mangle]
pub extern "C" fn cmd_print(mut cmd: *mut cmd) -> *mut i8 {
    let mut out: *mut i8 = std::ptr::null_mut::<i8>();
    let mut s: *mut i8 = std::ptr::null_mut::<i8>();
    s = unsafe { args_print((*cmd).args) };
    if (unsafe { *s }) as i32 != '\0' as i32 {
        (unsafe {
            xasprintf(
                &mut out as *mut *mut i8,
                b"%s %s\0" as *const u8 as *const i8,
                (*(*cmd).entry).name,
                s,
            )
        });
    } else {
        out = unsafe { xstrdup((*(*cmd).entry).name) };
    }
    (unsafe { free(s as *mut libc::c_void) });
    return out;
}
#[no_mangle]
pub extern "C" fn cmd_list_new() -> *mut cmd_list {
    let mut cmdlist: *mut cmd_list = std::ptr::null_mut::<cmd_list>();
    cmdlist = (unsafe {
        xcalloc(
            1 as i32 as size_t,
            ::core::mem::size_of::<cmd_list>() as u64,
        )
    }) as *mut cmd_list;
    (unsafe { (*cmdlist).references = 1 as i32 });
    let fresh6 = unsafe { cmd_list_next_group };
    (unsafe { cmd_list_next_group = cmd_list_next_group.wrapping_add(1) });
    (unsafe { (*cmdlist).group = fresh6 });
    (unsafe {
        (*cmdlist).list =
            xcalloc(1 as i32 as size_t, ::core::mem::size_of::<cmds>() as u64) as *mut cmds
    });
    (unsafe { (*(*cmdlist).list).tqh_first = std::ptr::null_mut::<cmd>() });
    (unsafe { (*(*cmdlist).list).tqh_last = &mut (*(*cmdlist).list).tqh_first });
    return cmdlist;
}
#[no_mangle]
pub extern "C" fn cmd_list_append(mut cmdlist: *mut cmd_list, mut cmd: *mut cmd) {
    (unsafe { (*cmd).group = (*cmdlist).group });
    (unsafe { (*cmd).qentry.tqe_next = std::ptr::null_mut::<cmd>() });
    (unsafe { (*cmd).qentry.tqe_prev = (*(*cmdlist).list).tqh_last });
    (unsafe { *(*(*cmdlist).list).tqh_last = cmd });
    (unsafe { (*(*cmdlist).list).tqh_last = &mut (*cmd).qentry.tqe_next });
}
#[no_mangle]
pub extern "C" fn cmd_list_append_all(mut cmdlist: *mut cmd_list, mut from: *mut cmd_list) {
    let mut cmd: *mut cmd = std::ptr::null_mut::<cmd>();
    cmd = unsafe { (*(*from).list).tqh_first };
    while !cmd.is_null() {
        (unsafe { (*cmd).group = (*cmdlist).group });
        cmd = unsafe { (*cmd).qentry.tqe_next };
    }
    if !(unsafe { (*(*from).list).tqh_first }).is_null() {
        (unsafe { *(*(*cmdlist).list).tqh_last = (*(*from).list).tqh_first });
        (unsafe { (*(*(*from).list).tqh_first).qentry.tqe_prev = (*(*cmdlist).list).tqh_last });
        (unsafe { (*(*cmdlist).list).tqh_last = (*(*from).list).tqh_last });
        (unsafe { (*(*from).list).tqh_first = std::ptr::null_mut::<cmd>() });
        (unsafe { (*(*from).list).tqh_last = &mut (*(*from).list).tqh_first });
    }
}
#[no_mangle]
pub extern "C" fn cmd_list_move(mut cmdlist: *mut cmd_list, mut from: *mut cmd_list) {
    if !(unsafe { (*(*from).list).tqh_first }).is_null() {
        (unsafe { *(*(*cmdlist).list).tqh_last = (*(*from).list).tqh_first });
        (unsafe { (*(*(*from).list).tqh_first).qentry.tqe_prev = (*(*cmdlist).list).tqh_last });
        (unsafe { (*(*cmdlist).list).tqh_last = (*(*from).list).tqh_last });
        (unsafe { (*(*from).list).tqh_first = std::ptr::null_mut::<cmd>() });
        (unsafe { (*(*from).list).tqh_last = &mut (*(*from).list).tqh_first });
    }
    let fresh7 = unsafe { cmd_list_next_group };
    (unsafe { cmd_list_next_group = cmd_list_next_group.wrapping_add(1) });
    (unsafe { (*cmdlist).group = fresh7 });
}
#[no_mangle]
pub extern "C" fn cmd_list_free(mut cmdlist: *mut cmd_list) {
    let mut cmd: *mut cmd = std::ptr::null_mut::<cmd>();
    let mut cmd1: *mut cmd = std::ptr::null_mut::<cmd>();
    (unsafe { (*cmdlist).references -= 1 });
    if (unsafe { (*cmdlist).references }) != 0 as i32 {
        return;
    }
    cmd = unsafe { (*(*cmdlist).list).tqh_first };
    while !cmd.is_null() && {
        cmd1 = unsafe { (*cmd).qentry.tqe_next };
        1 as i32 != 0
    } {
        if !(unsafe { (*cmd).qentry.tqe_next }).is_null() {
            (unsafe { (*(*cmd).qentry.tqe_next).qentry.tqe_prev = (*cmd).qentry.tqe_prev });
        } else {
            (unsafe { (*(*cmdlist).list).tqh_last = (*cmd).qentry.tqe_prev });
        }
        (unsafe { *(*cmd).qentry.tqe_prev = (*cmd).qentry.tqe_next });
        cmd_free(cmd);
        cmd = cmd1;
    }
    (unsafe { free((*cmdlist).list as *mut libc::c_void) });
    (unsafe { free(cmdlist as *mut libc::c_void) });
}
#[no_mangle]
pub extern "C" fn cmd_list_copy(
    mut cmdlist: *mut cmd_list,
    mut argc: i32,
    mut argv: *mut *mut i8,
) -> *mut cmd_list {
    let mut cmd: *mut cmd = std::ptr::null_mut::<cmd>();
    let mut new_cmdlist: *mut cmd_list = std::ptr::null_mut::<cmd_list>();
    let mut new_cmd: *mut cmd = std::ptr::null_mut::<cmd>();
    let mut group: u_int = unsafe { (*cmdlist).group };
    let mut s: *mut i8 = std::ptr::null_mut::<i8>();
    s = cmd_list_print(cmdlist, 0 as i32);
    (unsafe {
        log_debug(
            b"%s: %s\0" as *const u8 as *const i8,
            (*::core::mem::transmute::<&[u8; 14], &[i8; 14]>(b"cmd_list_copy\0")).as_ptr(),
            s,
        )
    });
    (unsafe { free(s as *mut libc::c_void) });
    new_cmdlist = cmd_list_new();
    cmd = unsafe { (*(*cmdlist).list).tqh_first };
    while !cmd.is_null() {
        if (unsafe { (*cmd).group }) != group {
            let fresh8 = unsafe { cmd_list_next_group };
            (unsafe { cmd_list_next_group = cmd_list_next_group.wrapping_add(1) });
            (unsafe { (*new_cmdlist).group = fresh8 });
            group = unsafe { (*cmd).group };
        }
        new_cmd = cmd_copy(cmd, argc, argv);
        cmd_list_append(new_cmdlist, new_cmd);
        cmd = unsafe { (*cmd).qentry.tqe_next };
    }
    s = cmd_list_print(new_cmdlist, 0 as i32);
    (unsafe {
        log_debug(
            b"%s: %s\0" as *const u8 as *const i8,
            (*::core::mem::transmute::<&[u8; 14], &[i8; 14]>(b"cmd_list_copy\0")).as_ptr(),
            s,
        )
    });
    (unsafe { free(s as *mut libc::c_void) });
    return new_cmdlist;
}
#[no_mangle]
pub extern "C" fn cmd_list_print(mut cmdlist: *mut cmd_list, mut escaped: i32) -> *mut i8 {
    let mut cmd: *mut cmd = std::ptr::null_mut::<cmd>();
    let mut next: *mut cmd = std::ptr::null_mut::<cmd>();
    let mut buf: *mut i8 = std::ptr::null_mut::<i8>();
    let mut this: *mut i8 = std::ptr::null_mut::<i8>();
    let mut len: size_t = 0;
    len = 1 as i32 as size_t;
    buf = (unsafe { xcalloc(1 as i32 as size_t, len) }) as *mut i8;
    cmd = unsafe { (*(*cmdlist).list).tqh_first };
    while !cmd.is_null() {
        this = cmd_print(cmd);
        len = (len as u64).wrapping_add((unsafe { strlen(this) }).wrapping_add(6 as i32 as u64))
            as size_t as size_t;
        buf = (unsafe { xrealloc(buf as *mut libc::c_void, len) }) as *mut i8;
        (unsafe { strlcat(buf, this, len) });
        next = unsafe { (*cmd).qentry.tqe_next };
        if !next.is_null() {
            if (unsafe { (*cmd).group }) != (unsafe { (*next).group }) {
                if escaped != 0 {
                    (unsafe { strlcat(buf, b" \\;\\; \0" as *const u8 as *const i8, len) });
                } else {
                    (unsafe { strlcat(buf, b" ;; \0" as *const u8 as *const i8, len) });
                }
            } else if escaped != 0 {
                (unsafe { strlcat(buf, b" \\; \0" as *const u8 as *const i8, len) });
            } else {
                (unsafe { strlcat(buf, b" ; \0" as *const u8 as *const i8, len) });
            }
        }
        (unsafe { free(this as *mut libc::c_void) });
        cmd = unsafe { (*cmd).qentry.tqe_next };
    }
    return buf;
}
#[no_mangle]
pub extern "C" fn cmd_list_first(mut cmdlist: *mut cmd_list) -> *mut cmd {
    return unsafe { (*(*cmdlist).list).tqh_first };
}
#[no_mangle]
pub extern "C" fn cmd_list_next(mut cmd: *mut cmd) -> *mut cmd {
    return unsafe { (*cmd).qentry.tqe_next };
}
#[no_mangle]
pub extern "C" fn cmd_list_all_have(mut cmdlist: *mut cmd_list, mut flag: i32) -> i32 {
    let mut cmd: *mut cmd = std::ptr::null_mut::<cmd>();
    cmd = unsafe { (*(*cmdlist).list).tqh_first };
    while !cmd.is_null() {
        if !(unsafe { (*(*cmd).entry).flags }) & flag != 0 {
            return 0 as i32;
        }
        cmd = unsafe { (*cmd).qentry.tqe_next };
    }
    return 1 as i32;
}
#[no_mangle]
pub extern "C" fn cmd_list_any_have(mut cmdlist: *mut cmd_list, mut flag: i32) -> i32 {
    let mut cmd: *mut cmd = std::ptr::null_mut::<cmd>();
    cmd = unsafe { (*(*cmdlist).list).tqh_first };
    while !cmd.is_null() {
        if (unsafe { (*(*cmd).entry).flags }) & flag != 0 {
            return 1 as i32;
        }
        cmd = unsafe { (*cmd).qentry.tqe_next };
    }
    return 0 as i32;
}
#[no_mangle]
pub extern "C" fn cmd_mouse_at(
    mut wp: *mut window_pane,
    mut m: *mut mouse_event,
    mut xp: *mut u_int,
    mut yp: *mut u_int,
    mut last: i32,
) -> i32 {
    let mut x: u_int = 0;
    let mut y: u_int = 0;
    if last != 0 {
        x = (unsafe { (*m).lx }).wrapping_add(unsafe { (*m).ox });
        y = (unsafe { (*m).ly }).wrapping_add(unsafe { (*m).oy });
    } else {
        x = (unsafe { (*m).x }).wrapping_add(unsafe { (*m).ox });
        y = (unsafe { (*m).y }).wrapping_add(unsafe { (*m).oy });
    }
    (unsafe {
        log_debug(
            b"%s: x=%u, y=%u%s\0" as *const u8 as *const i8,
            (*::core::mem::transmute::<&[u8; 13], &[i8; 13]>(b"cmd_mouse_at\0")).as_ptr(),
            x,
            y,
            if last != 0 {
                b" (last)\0" as *const u8 as *const i8
            } else {
                b"\0" as *const u8 as *const i8
            },
        )
    });
    if (unsafe { (*m).statusat }) == 0 as i32 && y >= (unsafe { (*m).statuslines }) {
        y = (y as u32).wrapping_sub(unsafe { (*m).statuslines }) as u_int as u_int;
    }
    if x < (unsafe { (*wp).xoff }) || x >= (unsafe { (*wp).xoff }).wrapping_add(unsafe { (*wp).sx })
    {
        return -(1 as i32);
    }
    if y < (unsafe { (*wp).yoff }) || y >= (unsafe { (*wp).yoff }).wrapping_add(unsafe { (*wp).sy })
    {
        return -(1 as i32);
    }
    if !xp.is_null() {
        (unsafe { *xp = x.wrapping_sub((*wp).xoff) });
    }
    if !yp.is_null() {
        (unsafe { *yp = y.wrapping_sub((*wp).yoff) });
    }
    return 0 as i32;
}
#[no_mangle]
pub extern "C" fn cmd_mouse_window(
    mut m: *mut mouse_event,
    mut sp: *mut *mut session,
) -> *mut winlink {
    let mut s: *mut session = std::ptr::null_mut::<session>();
    let mut w: *mut window = std::ptr::null_mut::<window>();
    let mut wl: *mut winlink = std::ptr::null_mut::<winlink>();
    if (unsafe { (*m).valid }) == 0 {
        return std::ptr::null_mut::<winlink>();
    }
    if (unsafe { (*m).s }) == -(1 as i32) || {
        s = unsafe { session_find_by_id((*m).s as u_int) };
        s.is_null()
    } {
        return std::ptr::null_mut::<winlink>();
    }
    if (unsafe { (*m).w }) == -(1 as i32) {
        wl = unsafe { (*s).curw };
    } else {
        w = unsafe { window_find_by_id((*m).w as u_int) };
        if w.is_null() {
            return std::ptr::null_mut::<winlink>();
        }
        wl = unsafe { winlink_find_by_window(&mut (*s).windows, w) };
    }
    if !sp.is_null() {
        (unsafe { *sp = s });
    }
    return wl;
}
#[no_mangle]
pub extern "C" fn cmd_mouse_pane(
    mut m: *mut mouse_event,
    mut sp: *mut *mut session,
    mut wlp: *mut *mut winlink,
) -> *mut window_pane {
    let mut wl: *mut winlink = std::ptr::null_mut::<winlink>();
    let mut wp: *mut window_pane = std::ptr::null_mut::<window_pane>();
    wl = cmd_mouse_window(m, sp);
    if wl.is_null() {
        return std::ptr::null_mut::<window_pane>();
    }
    if (unsafe { (*m).wp }) == -(1 as i32) {
        wp = unsafe { (*(*wl).window).active };
    } else {
        wp = unsafe { window_pane_find_by_id((*m).wp as u_int) };
        if wp.is_null() {
            return std::ptr::null_mut::<window_pane>();
        }
        if (unsafe { window_has_pane((*wl).window, wp) }) == 0 {
            return std::ptr::null_mut::<window_pane>();
        }
    }
    if !wlp.is_null() {
        (unsafe { *wlp = wl });
    }
    return wp;
}
#[no_mangle]
pub extern "C" fn cmd_template_replace(
    mut template: *const i8,
    mut s: *const i8,
    mut idx: i32,
) -> *mut i8 {
    let mut ch: i8 = 0;
    let mut buf: *mut i8 = std::ptr::null_mut::<i8>();
    let mut ptr: *const i8 = std::ptr::null::<i8>();
    let mut cp: *const i8 = std::ptr::null::<i8>();
    let quote: [i8; 6] = *(unsafe { ::core::mem::transmute::<&[u8; 6], &[i8; 6]>(b"\"\\$;~\0") });
    let mut replaced: i32 = 0;
    let mut quoted: i32 = 0;
    let mut len: size_t = 0;
    if (unsafe { strchr(template, '%' as i32) }).is_null() {
        return unsafe { xstrdup(template) };
    }
    buf = (unsafe { xmalloc(1 as i32 as size_t) }) as *mut i8;
    (unsafe { *buf = '\0' as i32 as i8 });
    len = 0 as i32 as size_t;
    replaced = 0 as i32;
    ptr = template;
    let mut current_block_22: u64;
    while (unsafe { *ptr }) as i32 != '\0' as i32 {
        let fresh9 = ptr;
        ptr = unsafe { ptr.offset(1) };
        ch = unsafe { *fresh9 };
        match ch as i32 {
            37 => {
                if ((unsafe { *ptr }) as i32) < '1' as i32
                    || (unsafe { *ptr }) as i32 > '9' as i32
                    || (unsafe { *ptr }) as i32 - '0' as i32 != idx
                {
                    if (unsafe { *ptr }) as i32 != '%' as i32 || replaced != 0 {
                        current_block_22 = 11584701595673473500;
                    } else {
                        replaced = 1 as i32;
                        current_block_22 = 2868539653012386629;
                    }
                } else {
                    current_block_22 = 2868539653012386629;
                }
                match current_block_22 {
                    11584701595673473500 => {}
                    _ => {
                        ptr = unsafe { ptr.offset(1) };
                        quoted = ((unsafe { *ptr }) as i32 == '%' as i32) as i32;
                        if quoted != 0 {
                            ptr = unsafe { ptr.offset(1) };
                        }
                        buf = (unsafe {
                            xrealloc(
                                buf as *mut libc::c_void,
                                len.wrapping_add((strlen(s)).wrapping_mul(3 as i32 as u64))
                                    .wrapping_add(1 as i32 as u64),
                            )
                        }) as *mut i8;
                        cp = s;
                        while (unsafe { *cp }) as i32 != '\0' as i32 {
                            if quoted != 0
                                && !(unsafe { strchr(quote.as_ptr(), *cp as i32) }).is_null()
                            {
                                let fresh10 = len;
                                len = len.wrapping_add(1);
                                (unsafe { *buf.offset(fresh10 as isize) = '\\' as i32 as i8 });
                            }
                            let fresh11 = len;
                            len = len.wrapping_add(1);
                            (unsafe { *buf.offset(fresh11 as isize) = *cp });
                            cp = unsafe { cp.offset(1) };
                        }
                        (unsafe { *buf.offset(len as isize) = '\0' as i32 as i8 });
                        continue;
                    }
                }
            }
            _ => {}
        }
        buf = (unsafe { xrealloc(buf as *mut libc::c_void, len.wrapping_add(2 as i32 as u64)) })
            as *mut i8;
        let fresh12 = len;
        len = len.wrapping_add(1);
        (unsafe { *buf.offset(fresh12 as isize) = ch });
        (unsafe { *buf.offset(len as isize) = '\0' as i32 as i8 });
    }
    return buf;
}
